package com.lovi.category.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.lovi.clients.ProductClient;
import com.lovi.param.PageParam;
import com.lovi.param.ProductHotParam;
import com.lovi.pojo.Category;
import com.lovi.category.mapper.CategoryMapper;
import com.lovi.category.service.CategoryService;
import com.lovi.pojo.User;
import com.lovi.utils.R;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;

import java.util.List;

@Service
@Slf4j
public class CategoryServiceImpl implements CategoryService {

    @Autowired
    private CategoryMapper categoryMapper;

    @Autowired
    private ProductClient productClient;
    /**
     * 查询类别数据,进行返回!
     *
     * @return r 类别数据集合
     */
    @Override
    public R list() {

        List<Category> categoryList = categoryMapper.selectList(null);
        R ok = R.ok("类别全部数据查询成功!", categoryList);
        log.info("CategoryServiceImpl.list业务结束，结果:{}",ok);
        return ok;
    }


    /**
     * 根据类别名称,查询类别对象
     *
     * @param categoryName
     * @return
     */
    @Override
    public R byName(String categoryName) {

        //封装查询参数
        QueryWrapper<Category> categoryQueryWrapper = new QueryWrapper<>();
        categoryQueryWrapper.eq("category_name",categoryName);
        //查询数据库
        Category category = categoryMapper.selectOne(categoryQueryWrapper);
        //结果封装
        if (category == null){
//            log.info("CategoryServiceImpl.byName业务结束，结果:类别查询失败");
            return R.fail("类别查询失败!");
        }
//        log.info("CategoryServiceImpl.byName业务结束，结果:{}","类别查询成功");
        return R.ok("类别查询成功!",category);
    }

    /**
     * 根据传入的热门类别名称集合!返回类别对应的id集合
     *
     * @param productHotParam
     * @return
     */
    @Override
    public R hotsCategory(ProductHotParam productHotParam) {

        //封装查询参数
        QueryWrapper<Category> queryWrapper = new QueryWrapper<>();
        queryWrapper.in("category_name",productHotParam.getCategoryName());
        queryWrapper.select("category_id"); //指定了查询结果只包含category_id这一列。

        //查询数据库
        List<Object> ids = categoryMapper.selectObjs(queryWrapper);//返回的结果将会是一个包含了所有匹配记录的category_id字段值的列表。

        R ok = R.ok("类别集合查询成功", ids);
        log.info("CategoryServiceImpl.hotsCategory业务结束，结果:{}",ok);
        return ok;
    }

    /**
     * 分页查询分类信息
     * @param pageParam
     * @return
     */
    @Override
    public R listPage(PageParam pageParam) {
        IPage<Category> page = new Page<>(pageParam.getCurrentPage(), pageParam.getPageSize());
        page = categoryMapper.selectPage(page, null);
        List<Category> categoryList = page.getRecords();
        long total = page.getTotal();
        return R.ok("查询成功",categoryList,total);
    }

    /**
     * 添加类别
     * 对了，如果类别和原来一样就不需要了，就不做继续添加处理了
     * @param category
     * @return
     */
    @Override
    public R save(Category category) {
        QueryWrapper<Category> wrapper = new QueryWrapper<>();
        wrapper.eq("category_name",category.getCategoryName());
        Long count = categoryMapper.selectCount(wrapper);
        if(count>0){
            return R.ok("已有，"+category.getCategoryName()+"类别，无需重复添加！");
        }
        //增加类别
        int insert = categoryMapper.insert(category);
        log.info("CategoryServiceImpl.save 结果为->{}", insert);

        return R.ok("类别添加成功");
    }

    /**
     * 删除某个类别，需要注意，如果，这个类别有商品引用，就删不了，因此还需要去调用商品客户端
     * 帮我们对比数据库
     * @param categoryId
     * @return
     */
    @Override
    public R remove(Integer categoryId) {
        //判断有没有商品引用(去商品表查一下有没有数据有categoryId的),
        Long count = productClient.adminCount(categoryId);
        if(count>0){
            log.info("CategoryServiceImpl.remove 结果为->{}", "类别删除失败");
            return R.fail("删除失败！该类别被"+count+"条商品引用");
        }
        //执行删除
        int i = categoryMapper.deleteById(categoryId);
        if(i>0){
            log.info("CategoryServiceImpl.remove 结果为->{}", i);

            return R.ok("类别删除成功！");
        }
        return R.fail("类别删除失败！");

    }

    /**
     * 类别信息修改（改类别名字）
     * @param category
     * @return
     */
    @Override
    public R update(Category category) {
        int i = categoryMapper.updateById(category);
        log.info("CategoryServiceImpl.update 结果为->{}", i);

        return R.ok("类别修改成功！");
    }
}
